// 后端服务器 - 音频文件上传和管理
import express from 'express';
import multer from 'multer';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import cors from 'cors';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();
const PORT = 3001;

// JWT密钥（生产环境应该使用环境变量）
const JWT_SECRET = 'voice_community_secret_key_2024';

// 中间件
app.use(cors());
app.use(express.json());
app.use(express.static('public'));
app.use('/uploads', express.static('uploads'));

// 确保上传目录存在
const uploadDir = path.join(__dirname, 'uploads');
if (!fs.existsSync(uploadDir)) {
  fs.mkdirSync(uploadDir, { recursive: true });
}

// 数据存储文件
const dataFile = path.join(__dirname, 'audio-data.json');
const usersFile = path.join(__dirname, 'users-data.json');

// 读取用户数据
function loadUsersData() {
  try {
    if (fs.existsSync(usersFile)) {
      const data = fs.readFileSync(usersFile, 'utf-8');
      return JSON.parse(data);
    }
  } catch (error) {
    console.error('读取用户数据失败:', error);
  }
  return [];
}

// 保存用户数据
function saveUsersData(data) {
  try {
    fs.writeFileSync(usersFile, JSON.stringify(data, null, 2), 'utf-8');
    return true;
  } catch (error) {
    console.error('保存用户数据失败:', error);
    return false;
  }
}

// 初始化默认管理员账户
function initDefaultAdmin() {
  const users = loadUsersData();
  const adminExists = users.some(user => user.role === 'admin');
  
  if (!adminExists) {
    const defaultAdmin = {
      id: 'admin_001',
      username: 'admin',
      password: bcrypt.hashSync('admin123', 10), // 默认密码：admin123
      role: 'admin',
      createdAt: new Date().toISOString()
    };
    
    users.push(defaultAdmin);
    saveUsersData(users);
    console.log('✅ 默认管理员账户已创建:');
    console.log('   用户名: admin');
    console.log('   密码: admin123');
    console.log('   请及时修改默认密码！');
  }
}

// 认证中间件
function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  if (!token) {
    return res.status(401).json({
      success: false,
      message: '访问令牌缺失'
    });
  }

  jwt.verify(token, JWT_SECRET, (err, user) => {
    if (err) {
      return res.status(403).json({
        success: false,
        message: '访问令牌无效'
      });
    }
    req.user = user;
    next();
  });
}

// 管理员权限中间件
function requireAdmin(req, res, next) {
  if (req.user && req.user.role === 'admin') {
    next();
  } else {
    return res.status(403).json({
      success: false,
      message: '需要管理员权限'
    });
  }
}

// 读取已保存的音频数据
function loadAudioData() {
  try {
    if (fs.existsSync(dataFile)) {
      const data = fs.readFileSync(dataFile, 'utf-8');
      return JSON.parse(data);
    }
  } catch (error) {
    console.error('读取数据文件失败:', error);
  }
  return [];
}

// 保存音频数据
function saveAudioData(data) {
  try {
    fs.writeFileSync(dataFile, JSON.stringify(data, null, 2), 'utf-8');
    return true;
  } catch (error) {
    console.error('保存数据文件失败:', error);
    return false;
  }
}

// 配置Multer存储
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, uploadDir);
  },
  filename: (req, file, cb) => {
    // 生成带时间戳的文件名，避免覆盖
    const timestamp = Date.now();
    const randomStr = Math.random().toString(36).substring(2, 8);
    const ext = path.extname(file.originalname);
    const baseName = path.basename(file.originalname, ext);
    
    // 格式: baseName_timestamp_random.ext
    const newFileName = `${baseName}_${timestamp}_${randomStr}${ext}`;
    cb(null, newFileName);
  }
});

// 文件过滤器
const fileFilter = (req, file, cb) => {
  const allowedTypes = ['audio/wav', 'audio/mpeg', 'audio/mp3', 'audio/x-wav'];
  
  if (allowedTypes.includes(file.mimetype)) {
    cb(null, true);
  } else {
    cb(new Error('只允许上传WAV或MP3格式的音频文件'), false);
  }
};

const upload = multer({
  storage: storage,
  fileFilter: fileFilter,
  limits: {
    fileSize: 20 * 1024 * 1024  // 20MB限制
  }
});

// API路由

// 用户登录
app.post('/api/auth/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: '用户名和密码不能为空'
      });
    }

    const users = loadUsersData();
    const user = users.find(u => u.username === username);
    
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码错误'
      });
    }

    const isValidPassword = await bcrypt.compare(password, user.password);
    if (!isValidPassword) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码错误'
      });
    }

    // 生成JWT令牌
    const token = jwt.sign(
      { 
        id: user.id, 
        username: user.username, 
        role: user.role 
      },
      JWT_SECRET,
      { expiresIn: '24h' }
    );

    res.json({
      success: true,
      message: '登录成功',
      token: token,
      user: {
        id: user.id,
        username: user.username,
        role: user.role
      }
    });
  } catch (error) {
    console.error('登录失败:', error);
    res.status(500).json({
      success: false,
      message: '登录失败',
      error: error.message
    });
  }
});

// 验证令牌
app.get('/api/auth/verify', authenticateToken, (req, res) => {
  res.json({
    success: true,
    user: req.user
  });
});

// 获取用户列表（仅管理员）
app.get('/api/auth/users', authenticateToken, requireAdmin, (req, res) => {
  try {
    const users = loadUsersData();
    const safeUsers = users.map(u => ({ id: u.id, username: u.username, role: u.role, createdAt: u.createdAt }));
    res.json({ success: true, data: safeUsers, count: safeUsers.length });
  } catch (error) {
    res.status(500).json({ success: false, message: '获取用户列表失败', error: error.message });
  }
});

// 删除管理员（仅管理员）
app.delete('/api/auth/users/:id', authenticateToken, requireAdmin, (req, res) => {
  try {
    const userId = req.params.id;
    const users = loadUsersData();

    const userIndex = users.findIndex(u => u.id === userId);
    if (userIndex === -1) {
      return res.status(404).json({ success: false, message: '用户不存在' });
    }

    const targetUser = users[userIndex];
    // 仅允许删除管理员用户（按需求）
    if (targetUser.role !== 'admin') {
      return res.status(400).json({ success: false, message: '仅支持删除管理员用户' });
    }

    // 禁止删除最后一个管理员
    const adminCount = users.filter(u => u.role === 'admin').length;
    if (adminCount <= 1) {
      return res.status(400).json({ success: false, message: '无法删除最后一个管理员' });
    }

    users.splice(userIndex, 1);
    saveUsersData(users);
    return res.json({ success: true, message: '管理员已删除' });
  } catch (error) {
    return res.status(500).json({ success: false, message: '删除失败', error: error.message });
  }
});

// 重置管理员密码（仅管理员）
app.patch('/api/auth/users/:id/password', authenticateToken, requireAdmin, async (req, res) => {
  try {
    const userId = req.params.id;
    const { newPassword } = req.body || {};
    if (!newPassword || typeof newPassword !== 'string' || newPassword.length < 6) {
      return res.status(400).json({ success: false, message: '新密码至少6位' });
    }

    const users = loadUsersData();
    const user = users.find(u => u.id === userId);
    if (!user) {
      return res.status(404).json({ success: false, message: '用户不存在' });
    }

    if (user.role !== 'admin') {
      return res.status(400).json({ success: false, message: '仅支持重置管理员密码' });
    }

    user.password = await bcrypt.hash(newPassword, 10);
    saveUsersData(users);
    return res.json({ success: true, message: '密码已更新' });
  } catch (error) {
    return res.status(500).json({ success: false, message: '更新失败', error: error.message });
  }
});

// 创建管理员账户（仅限已认证的管理员）
app.post('/api/auth/create-admin', authenticateToken, requireAdmin, async (req, res) => {
  try {
    const { username, password } = req.body;
    
    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: '用户名和密码不能为空'
      });
    }

    if (password.length < 6) {
      return res.status(400).json({
        success: false,
        message: '密码长度至少6位'
      });
    }

    const users = loadUsersData();
    const existingUser = users.find(u => u.username === username);
    
    if (existingUser) {
      return res.status(400).json({
        success: false,
        message: '用户名已存在'
      });
    }

    const hashedPassword = await bcrypt.hash(password, 10);
    const newAdmin = {
      id: `admin_${Date.now()}`,
      username: username,
      password: hashedPassword,
      role: 'admin',
      createdAt: new Date().toISOString(),
      createdBy: req.user.id
    };

    users.push(newAdmin);
    
    if (saveUsersData(users)) {
      res.json({
        success: true,
        message: '管理员账户创建成功',
        user: {
          id: newAdmin.id,
          username: newAdmin.username,
          role: newAdmin.role
        }
      });
    } else {
      res.status(500).json({
        success: false,
        message: '保存用户数据失败'
      });
    }
  } catch (error) {
    console.error('创建管理员失败:', error);
    res.status(500).json({
      success: false,
      message: '创建管理员失败',
      error: error.message
    });
  }
});

// 获取所有音频列表
app.get('/api/audio-list', (req, res) => {
  try {
    const audioList = loadAudioData();
    res.json({
      success: true,
      data: audioList,
      count: audioList.length
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '获取音频列表失败',
      error: error.message
    });
  }
});

// 上传音频包（三个文件）- 需要管理员权限
app.post('/api/upload-audio-package', 
  authenticateToken,
  requireAdmin,
  upload.fields([
    { name: 'origin', maxCount: 1 },
    { name: 'basic', maxCount: 1 },
    { name: 'advance', maxCount: 1 }
  ]), 
  (req, res) => {
    try {
      const packageName = req.body.packageName;
      
      if (!packageName) {
        return res.status(400).json({
          success: false,
          message: '请提供音频包名称'
        });
      }

      if (!req.files || !req.files.origin || !req.files.basic || !req.files.advance) {
        return res.status(400).json({
          success: false,
          message: '请上传所有三个音频文件'
        });
      }

      // 获取上传的文件信息
      const originFile = req.files.origin[0];
      const basicFile = req.files.basic[0];
      const advanceFile = req.files.advance[0];

      // 创建音频包数据
      const audioPackage = {
        id: `pkg_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
        name: packageName,
        uploadTime: new Date().toISOString(),
        files: {
          origin: {
            filename: originFile.filename,
            originalName: originFile.originalname,
            size: originFile.size,
            path: `/uploads/${originFile.filename}`
          },
          basic: {
            filename: basicFile.filename,
            originalName: basicFile.originalname,
            size: basicFile.size,
            path: `/uploads/${basicFile.filename}`
          },
          advance: {
            filename: advanceFile.filename,
            originalName: advanceFile.originalname,
            size: advanceFile.size,
            path: `/uploads/${advanceFile.filename}`
          }
        }
      };

      // 加载现有数据
      const audioList = loadAudioData();
      
      // 添加新数据
      audioList.push(audioPackage);
      
      // 保存到文件
      if (saveAudioData(audioList)) {
        res.json({
          success: true,
          message: '音频包上传成功',
          data: audioPackage
        });
      } else {
        // 保存失败，删除上传的文件
        fs.unlinkSync(originFile.path);
        fs.unlinkSync(basicFile.path);
        fs.unlinkSync(advanceFile.path);
        
        res.status(500).json({
          success: false,
          message: '保存数据失败'
        });
      }
    } catch (error) {
      console.error('上传失败:', error);
      res.status(500).json({
        success: false,
        message: '上传失败',
        error: error.message
      });
    }
  }
);

// 删除音频包 - 需要管理员权限
app.delete('/api/audio-package/:id', authenticateToken, requireAdmin, (req, res) => {
  try {
    const packageId = req.params.id;
    const audioList = loadAudioData();
    
    // 找到要删除的音频包
    const packageIndex = audioList.findIndex(pkg => pkg.id === packageId);
    
    if (packageIndex === -1) {
      return res.status(404).json({
        success: false,
        message: '音频包不存在'
      });
    }

    const audioPackage = audioList[packageIndex];
    
    // 删除文件
    try {
      const files = [
        path.join(__dirname, 'uploads', audioPackage.files.origin.filename),
        path.join(__dirname, 'uploads', audioPackage.files.basic.filename),
        path.join(__dirname, 'uploads', audioPackage.files.advance.filename)
      ];
      
      files.forEach(filePath => {
        if (fs.existsSync(filePath)) {
          fs.unlinkSync(filePath);
        }
      });
    } catch (error) {
      console.error('删除文件失败:', error);
    }
    
    // 从列表中移除
    audioList.splice(packageIndex, 1);
    
    // 保存更新后的数据
    saveAudioData(audioList);
    
    res.json({
      success: true,
      message: '音频包删除成功'
    });
  } catch (error) {
    console.error('删除失败:', error);
    res.status(500).json({
      success: false,
      message: '删除失败',
      error: error.message
    });
  }
});

// 错误处理中间件
app.use((error, req, res, next) => {
  if (error instanceof multer.MulterError) {
    if (error.code === 'LIMIT_FILE_SIZE') {
      return res.status(400).json({
        success: false,
        message: '文件过大，单个文件不能超过20MB'
      });
    }
  }
  
  res.status(500).json({
    success: false,
    message: error.message || '服务器错误'
  });
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`🚀 后端服务器运行在 http://localhost:${PORT}`);
  console.log(`📁 上传目录: ${uploadDir}`);
  console.log(`💾 数据文件: ${dataFile}`);
  console.log(`👥 用户数据: ${usersFile}`);
  
  // 初始化默认管理员账户
  initDefaultAdmin();
});

